home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / CIncludes / OpenTptCommon.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-01  |  12.1 KB  |  462 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        OpenTptCommon.h
  3.  
  4.     Contains:    Equates for Open Transport development needed both by clients
  5.                 and by kernel.
  6.  
  7.     Copyright:    © 1993-1996 by Apple Computer, Inc. and Mentat Inc., all rights reserved.
  8.  
  9.  
  10. */
  11.  
  12. #ifndef __OPENTPTCOMMON__
  13. #define __OPENTPTCOMMON__
  14.  
  15. #ifndef __OPENTRANSPORT__
  16. #include <OpenTransport.h>
  17. #endif
  18. #ifndef _MPS_STREAM_
  19. #include <mistream.h>
  20. #endif
  21.  
  22. #if GENERATING68K && defined(__MWERKS__)
  23. #pragma pointers_in_D0
  24. #endif
  25.  
  26. /*******************************************************************************
  27. ** Some typedefs
  28. ********************************************************************************/
  29.  
  30. typedef long        OTCommand;        /* The command code in STREAMS messages        */
  31. typedef SInt16        OTRelease;        /* An internal OT typedef                    */
  32.  
  33. /*******************************************************************************
  34. ** Some private IOCTL constants we need to know
  35. ********************************************************************************/
  36.  
  37. enum
  38. {
  39.     I_OTYieldPort    = MIOC_CMD(MIOC_OT, 4)    /* request to yield the port                */
  40. };
  41.  
  42. /*******************************************************************************
  43. ** Some defines
  44. ********************************************************************************/
  45.  
  46. #define MI_BIG_ENDIAN            1
  47. #undef    MI_LITTLE_ENDIAN
  48.  
  49. //
  50. // For static members that need to match pascal functions
  51. //
  52. #define _FSDECL                static pascal
  53. #define _FSDEF                pascal
  54.  
  55. /*    -------------------------------------------------------------------------
  56.     ** Bitmap functions
  57.     **
  58.     ** These functions deal with a bitmap that is multiple-bytes long
  59.     ------------------------------------------------------------------------- */
  60.  
  61. #ifdef __cplusplus
  62. extern "C" {
  63. #endif
  64.     //
  65.     // Set the first clear bit in "bitMap", starting with bit "startBit",
  66.     // giving up after "numBits".  Returns the bit # that was set, or
  67.     // a kOTNotFoundErr if there was no clear bit available
  68.     //
  69. OTResult    OTSetFirstClearBit(UInt8* bitMap, size_t startBit, size_t numBits);
  70.     //
  71.     // Standard clear, set and test bit functions
  72.     //
  73. Boolean        OTClearBit(UInt8* bitMap, size_t bitNo);
  74. Boolean        OTSetBit(UInt8* bitMap, size_t bitNo);
  75. Boolean        OTTestBit(UInt8* bitMap, size_t bitNo);
  76.  
  77. #ifdef __cplusplus
  78. }
  79. #endif
  80.  
  81. /*    -------------------------------------------------------------------------
  82.     ** OTHashList
  83.     **
  84.     ** This implements a simple, but efficient hash list.  It is not
  85.     ** thread-safe.
  86.     ------------------------------------------------------------------------- */
  87.  
  88. typedef struct OTHashList    OTHashList;
  89.  
  90. typedef UInt32 (* _CDECL OTHashProcPtr)(OTLink* linkToHash);
  91. typedef Boolean (* _CDECL OTHashSearchProcPtr)(const void* ref, OTLink* linkToCheck);
  92.  
  93. #ifdef __cplusplus
  94. extern "C" {
  95. #endif
  96.     //
  97.     // Return the number of bytes of memory needed to create a hash list
  98.     // of at least "numEntries" entries.
  99.     //
  100. size_t        OTCalculateHashListMemoryNeeds(size_t numEntries);
  101.     //
  102.     // Create an OTHashList from "memory".  Return an error if it
  103.     // couldn't be done.
  104.     //
  105. OTResult    OTInitHashList(void* memory, size_t numBytes, OTHashProcPtr);
  106. void        OTAddToHashList(OTHashList*, OTLink*);
  107. Boolean        OTRemoveLinkFromHashList(OTHashList*, OTLink*);
  108. Boolean        OTIsInHashList(OTHashList*, OTLink*);
  109. OTLink*        OTFindInHashList(OTHashList*, OTHashSearchProcPtr proc,
  110.                             const void* refPtr, UInt32 hashValue);
  111. OTLink*        OTRemoveFromHashList(OTHashList*, OTHashSearchProcPtr proc,
  112.                                  const void* refPtr, UInt32 hashValue);
  113.  
  114. #ifdef __cplusplus
  115. }
  116. #endif
  117.  
  118. struct OTHashList
  119. {
  120.     OTHashProcPtr        fHashProc;
  121.     size_t                fHashTableSize;
  122.     OTLink**            fHashBuckets;
  123.  
  124. #ifdef __cplusplus
  125.             void        Add(OTLink* toAdd)
  126.                             { OTAddToHashList(this, toAdd); }
  127.                             
  128.             Boolean        RemoveLink(OTLink* toRemove)
  129.                             { return OTRemoveLinkFromHashList(this, toRemove); }
  130.                             
  131.             OTLink*        Remove(OTHashSearchProcPtr proc,
  132.                                const void* refPtr, UInt32 hashValue)
  133.                             { return OTRemoveFromHashList(this, proc, refPtr, hashValue); }
  134.                             
  135.             Boolean        IsInList(OTLink* toFind)
  136.                             { return OTIsInHashList(this, toFind); }
  137.                             
  138.             OTLink*        FindLink(OTHashSearchProcPtr proc, const void* refPtr,
  139.                                  UInt32 hash)
  140.                             {    return OTFindInHashList(this, proc, refPtr, hash); }
  141. #endif
  142. };
  143.  
  144.  
  145. /*    -------------------------------------------------------------------------
  146.     ** Random functions
  147.     ** 
  148.     ** These implement a very simple random number generator
  149.     ------------------------------------------------------------------------- */
  150.  
  151.     #ifdef __cplusplus
  152.     extern "C" {
  153.     #endif
  154.     
  155.     UInt32    OTGetRandomSeed();
  156.     UInt32    OTGetRandomNumber(UInt32* seed, UInt32 lo, UInt32 hi);
  157.     
  158.     #ifdef __cplusplus
  159.     }
  160.     #endif
  161.  
  162.  
  163. /*******************************************************************************
  164. ** XmitRecord Class
  165. ** 
  166. ** This class is used when sending "write"-type commands, where we need
  167. ** information to be able to complete a write to the client when it is 
  168. ** finished.
  169. ********************************************************************************/
  170.  
  171. struct XmitRecord
  172. {
  173.         OTLink        fLink;
  174.         void*        provider;
  175.         void*        dataBuf;
  176.         size_t        dataLen;
  177.         SInt16        ackCount;
  178. };
  179.     
  180. /*******************************************************************************
  181. ** Miscellaneous functions
  182. ********************************************************************************/
  183.  
  184. #ifdef __cplusplus
  185. extern "C" {
  186. #endif
  187. //
  188. // Return true if we are at interrupt level
  189. //
  190. Boolean        OTIsAtInterruptLevel(void);
  191. //
  192. // Return true if we are currently at either system task time, or we
  193. // are running a deferred task procedure from system task time.
  194. //
  195. Boolean     OTCanLoadLibraries(void);
  196. void        OTEnterCriticalSection(void);
  197. void        OTLeaveCriticalSection(void);
  198.  
  199. #ifdef __cplusplus
  200. }
  201. #endif
  202.  
  203. /*******************************************************************************
  204. ** Port ref functions
  205. ********************************************************************************/
  206.  
  207. #ifdef __cplusplus
  208. extern "C" {
  209. #endif
  210.     
  211.     pascal OTPortRef    OTSetDeviceTypeInPortRef(OTPortRef ref, UInt16 devType);
  212.     pascal OTPortRef    OTSetBusTypeInPortRef(OTPortRef ref, UInt8 busType);
  213.  
  214.     pascal Boolean        OTMakePortName(char* buffer, const char* moduleName,
  215.                                        OTPortRef);
  216.     
  217. #ifdef __cplusplus
  218. }
  219. #endif
  220.     
  221. /*******************************************************************************
  222. ** Some defines
  223. ********************************************************************************/
  224.  
  225. /*    -------------------------------------------------------------------------
  226.     IOCtls used by OpenTransport
  227.     ------------------------------------------------------------------------- */
  228.  
  229.     typedef int    OTNotifyType;
  230.     
  231.     enum
  232.     {
  233.         kOTNotifyAllModules = 0, kOTNotifyInterestedModules = 1,
  234.         kOTNotifyControlModules = 2
  235.     };
  236.     
  237.     struct OTIOCtlNotifyInfo
  238.     {
  239.         OTEventCode    fCode;        // Event Code
  240.         void*        fCookie;    // Cookie associated with it
  241.         UInt32        fNotifyType;// Who to notify
  242.     };
  243.     
  244.     typedef struct OTIoctlNotifyInfo    OTIoctlNotifyInfo;
  245.  
  246.     enum
  247.     {
  248.         I_OTNotifyAllClients    = MIOC_CMD(MIOC_OT, 50),
  249.         I_OTSetPowerLevel        = MIOC_CMD(MIOC_OT, 51)
  250.     };
  251.     
  252. /*    -------------------------------------------------------------------------
  253.     Some equates for kPROTOCOLEVENTs that normal clients don't need to 
  254.     know.
  255.     ------------------------------------------------------------------------- */
  256.  
  257.     enum
  258.     {
  259.         kHiPriProtocolEvent        = 0x08000000    /* Bit to be a high-priority event        */
  260.     };
  261.  
  262.     #define IsHiPriProtocolEvent(x)        (((x) & 0xff000000) == (kPROTOCOLEVENT | kHiPriProtocolEvent))
  263.     #define StripProtocolEvent(x)        ((x) & ~kHiPriProtocolEvent)
  264.     //
  265.     // Use this template to define your preferences if you use
  266.     // the TStreamGroup and TStreamFamily infrastructure
  267.     //
  268.     #define OTPreferencesFields(num)            \
  269.         UInt16            fVersion;                \
  270.         UInt16            fNumPrefs;                \
  271.         OTPortRef        fPort;                    \
  272.         OTLink            fLink;                    \
  273.         void*            fPrefs[num]
  274.     //
  275.     // This template is used to define the first set
  276.     // of fields in each individual preference array
  277.     //
  278.     #define OTPreferenceFields                    \
  279.         UInt16            fVersion;                \
  280.         UInt16            fSize
  281.         
  282.     //
  283.     // Define to tell infrastructure you want the main preference
  284.     // structure instead of a substructure.
  285.     //
  286.     enum
  287.     {
  288.         kOTPrefStructureCode = (UInt32)0xffffffffU
  289.     };
  290.     
  291.  
  292. /*******************************************************************************
  293. ** Functions to convert xti/mac errors to OSStatus'
  294. ********************************************************************************/
  295.  
  296. #ifdef __cplusplus
  297. extern "C" {
  298. #endif
  299.  
  300. pascal OSStatus OTConvertError(OTXTIErr xtiErr, OTUnixErr macErr);
  301.                     
  302. #ifdef __cplusplus
  303. }
  304. #endif
  305.  
  306. #ifdef __cplusplus
  307. //
  308. // Macro for Speed
  309. //
  310. inline OSStatus OTDoConvertError(long xtiErr, long macErr)
  311. {
  312.     return xtiErr == 0 ? kOTNoError : OTConvertError((OTXTIErr)xtiErr, (OTUnixErr)macErr);
  313. }
  314.  
  315. #else
  316.  
  317. #define OTDoConvertError(xtiErr, macErr)    \
  318.     ((xtiErr) == 0 ? kOTNoError : OTConvertError((OTXTIErr)(xtiErr), (OTUnixErr)(macErr)))
  319.     
  320. #endif
  321.  
  322. /*******************************************************************************
  323. ** Some efficient implementations of BigEndian and LittleEndian words
  324. ********************************************************************************/
  325.  
  326. #ifdef MI_BIG_ENDIAN
  327. //
  328. // Since Open Transport is 68020 and better only, we don't have to
  329. // worry about alignment problems.
  330. //
  331. #define GetBigEndian16At(ptr)        (*(UInt16*)(ptr))
  332. #define GetBigEndian32At(ptr)        (*(UInt32*)(ptr))    
  333. #define SetBigEndian16At(ptr, val)    { *(UInt16*)(ptr) = (UInt16)(val); }
  334. #define SetBigEndian32At(ptr, val)    { *(UInt32*)(ptr) = (UInt32)(val); }
  335.  
  336. #else
  337.  
  338. #define GetBigEndian16At(ptr)                        \
  339.         ((Uint16)(((((UInt8*)ptr)[0]) << 8) + ((UInt8*)ptr)[1]))
  340.  
  341. #define GetBigEndian32At(ptr)                        \
  342.         ((UInt32)(((((UInt8*)ptr)[0]) << 24) +        \
  343.                     (((UInt8*)ptr)[1]  << 16) +        \
  344.                     (((UInt8*)ptr)[2]  << 8) +        \
  345.                      ((UInt8*)ptr)[3]))
  346.  
  347. #define SetBigEndian16At(ptr, val)                \
  348.         {                                            \
  349.             ((UInt8*)ptr)[0] = (UInt8)(val >> 8);    \
  350.             ((UInt8*)ptr)[1] = (UInt8)(val);        \
  351.         }
  352.         
  353. #define SetBigEndian32At(ptr, val)                \
  354.         {                                            \
  355.             ((UInt8*)ptr)[0] = (UInt8)(val >> 24);    \
  356.             ((UInt8*)ptr)[1] = (UInt8)(val >> 16);    \
  357.             ((UInt8*)ptr)[2] = (UInt8)(val >> 8);    \
  358.             ((UInt8*)ptr)[3] = (UInt8)(val);        \
  359.         }
  360.  
  361. #endif
  362.         
  363. #ifdef MI_LITTLE_ENDIAN
  364.  
  365. #define GetLittleEndian16At(ptr)            (*(UInt16*)(ptr))
  366. #define GetLittleEndian32At(ptr)            (*(UInt32*)(ptr))    
  367. #define SetLittleEndian16At(ptr, val)    { *(UInt16*)(ptr) = (UInt16)(val); }
  368. #define SetLittleEndian32At(ptr, val)    { *(UInt32*)(ptr) = (UInt32)(val); }
  369.  
  370. #else
  371.  
  372. #define GetLittleEndian16At(ptr)                    \
  373.         ((Uint16)(((((UInt8*)ptr)[1]) << 8) + ((UInt8*)ptr)[0]))
  374.  
  375. #define GetLittleEndian32At(ptr)                    \
  376.         ((UInt32)(((((UInt8*)ptr)[3]) << 24) +        \
  377.                     (((UInt8*)ptr)[2]  << 16) +        \
  378.                     (((UInt8*)ptr)[1]  << 8) +        \
  379.                      ((UInt8*)ptr)[0]))
  380.  
  381. #define SetLittleEndian16At(ptr, val)                \
  382.         {                                            \
  383.             ((UInt8*)ptr)[1] = (UInt8)(val >> 8);    \
  384.             ((UInt8*)ptr)[0] = (UInt8)(val);        \
  385.         }
  386.         
  387. #define SetLittleEndian32At(ptr, val)                \
  388.         {                                            \
  389.             ((UInt8*)ptr)[3] = (UInt8)(val >> 24);    \
  390.             ((UInt8*)ptr)[2] = (UInt8)(val >> 16);    \
  391.             ((UInt8*)ptr)[1] = (UInt8)(val >> 8);    \
  392.             ((UInt8*)ptr)[0] = (UInt8)(val);        \
  393.         }
  394.  
  395. #endif
  396.  
  397. #ifdef __cplusplus
  398.  
  399. /*    -------------------------------------------------------------------------
  400.     TOTBaseObject
  401.     
  402.     This is the base class for Open Transport objects that DO NOT need to 
  403.     be 68K aligned.
  404.     ------------------------------------------------------------------------- */
  405.  
  406. #if USESINGLEOBJECT
  407.     class TOTBaseObject : public SingleObject
  408. #else
  409.     class TOTBaseObject
  410. #endif
  411.     {
  412.         EXTRA_VTABLE_SLOT
  413.         
  414.         public:
  415.                             _CT TOTBaseObject() {}
  416.             virtual            _DT TOTBaseObject();
  417.             
  418.         private:
  419.                             _CT TOTBaseObject(const TOTBaseObject&);
  420.                     void    operator=(const TOTBaseObject&);
  421.     };
  422.     
  423. #if GENERATINGPOWERPC
  424. #pragma options align=mac68k
  425. #endif
  426.  
  427. /*    -------------------------------------------------------------------------
  428.     TOTAlignedObject
  429.  
  430.     This is the base class for Open Transport objects that DO need to 
  431.     be 68K aligned.
  432.     ------------------------------------------------------------------------- */
  433.  
  434. #if USESINGLEOBJECT
  435.     class TOTAlignedObject : public SingleObject
  436. #else
  437.     class TOTAlignedObject
  438. #endif
  439.     {
  440.         EXTRA_VTABLE_SLOT
  441.         
  442.         public:
  443.                             _CT TOTAlignedObject() {}
  444.             virtual            _DT TOTAlignedObject();
  445.  
  446.         private:
  447.                             _CT TOTAlignedObject(const TOTAlignedObject&);
  448.                     void    operator=(const TOTAlignedObject&);
  449.     };
  450.  
  451. #if GENERATINGPOWERPC
  452. #pragma options align=reset
  453. #endif
  454.  
  455. #endif
  456.  
  457. #if GENERATING68K && defined(__MWERKS__)
  458. #pragma pointers_in_A0
  459. #endif
  460.  
  461. #endif    /* __OPENTPTCOMMON__    */
  462.